home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 11 / Cream of the Crop 11-2.iso / os2 / gnucal.zip / gcal-us.info-1 (.txt) < prev    next >
GNU Info File  |  1995-12-20  |  28KB  |  551 lines
  1. This is Info file ./gcal-us.info, produced by Makeinfo-1.63 from the
  2. input file ./doc/tex/gcal-us.texi.
  3.   This file documents Gcal, a program for printing calendars.  It
  4. displays a calendar for a month or for a year, eternal holiday lists
  5. and fixed date warning lists; in many ways.  Gcal correctly omits the
  6. dates that were skipped when the current Gregorian calendar replaced
  7. the earlier Julian calendar.
  8.   Copyright (C) 1994, 1995 Thomas Esken
  9.   This is the first edition of the Gcal documentation.
  10.   Permission is granted to make and distribute verbatim copies of this
  11. manual provided the copyright notice and this permission notice are
  12. preserved on all copies.
  13.   Permission is granted to copy and distribute modified versions of this
  14. manual under the conditions for verbatim copying, provided that the
  15. entire resulting derived work is distributed under the terms of a
  16. permission notice identical to this one.
  17.   Permission is granted to copy and distribute translations of this
  18. manual into another language, under the above conditions for modified
  19. versions, except that this permission notice may be stated in a
  20. translation approved by the Foundation.
  21.   Any suggestions, improvements, extensions, bug reports, donations,
  22. proposals for contract work, and so forth are welcome!  Please send
  23. them directly to my Email address.  If you like my work, I'd appreciate
  24. a postcard from you!
  25.                                 \\\_''/'
  26. -------------------------oOO    (/o-o\)    OOo-------------------------
  27. Thomas Esken                o  (.  "  .)  o   Internet :
  28. Im Hagenfeld 84              \___) ~ (___/      <esken@uni-muenster.de>
  29. D-48147 M"unster; GERMANY                     Phone : (+49) 0251 232585
  30. File: gcal-us.info,  Node: Top,  Next: Gcal Introduction,  Prev: (dir),  Up: (dir)
  31.   Gcal is a program for printing calendars.  It displays a calendar for
  32. a month or for a year, eternal holiday lists and fixed date warning
  33. lists; in many ways.  Gcal correctly omits the dates that were skipped
  34. when the current Gregorian calendar replaced the earlier Julian
  35. calendar.
  36.   This is Edition 0.24 of the Gcal documentation, 20 December 1995, for
  37. Gcal 0.39.
  38.   Any suggestions, improvements, extensions, bug reports, donations,
  39. proposals for contract work, and so forth are welcome!  Please send
  40. them directly to my Email address.  If you like my work, I'd appreciate
  41. a postcard from you!
  42.                                 \\\_''/'
  43. -------------------------oOO    (/o-o\)    OOo-------------------------
  44. Thomas Esken                o  (.  "  .)  o   Internet :
  45. Im Hagenfeld 84              \___) ~ (___/      <esken@uni-muenster.de>
  46. D-48147 M"unster; GERMANY                     Phone : (+49) 0251 232585
  47. * Menu:
  48. * Gcal Introduction::      Gcal in brief.
  49. * Invoking Gcal::          How to run the `gcal' program.
  50. * Eternal holidays::       How to create an Eternal holiday list.
  51. * Fixed date warnings::    How to create a Fixed date warning list.
  52. Appendices
  53. * Todays calendar::        Genesis of the Gregorian calendar.
  54. * Meta Symbols::           Meta Symbols used in this document.
  55. * Coding scheme::          Coding scheme of date part in resource file.
  56. * Environment variables::  Respected Environment variables.
  57. * Error codes::            Which Error codes does Gcal return?
  58. Indices
  59. * Argument Index::         Index of Command line arguments.
  60. * Variable Index::         Index of Environment variables.
  61. * Concept Index::          Concept Index.
  62.   --- The Detailed Node Listing ---
  63. Invoking Gcal
  64. * Command line arguments::         Command line arguments.
  65. * The GCAL environment variable::  How to use the `GCAL' environment variable.
  66. Command line arguments
  67. * Options::               How to use Options.
  68. * Response file::         How to use a `@FILE' Response file.
  69. * Actual date modifier::  How to use a `%DATE' Actual date modifier.
  70. * Commands::              How to use Commands.
  71. Options
  72. * Common options::        How to use Common options.
  73. * Global options::        How to use Global options.
  74. * Calendar options::      How to use Calendar options.
  75. * Date warning options::  How to use Date warning options.
  76. Commands
  77. * Single commands::        How to use a Single command.
  78. * 3-Month mode commands::  How to use a 3-Month mode command.
  79. * Command lists::          How to use a List of commands.
  80. * Command ranges::         How to use a Range of commands.
  81. Fixed date warnings
  82. * Resource file::           How to use a Resource file.
  83. * Resource file examples::  Examples of Resource file entries.
  84. Resource file
  85. * Structure of resource file::  How to write a Resource file.
  86. * Date part of a line::         How to write the Date part.
  87. * Text part of a line::         How to write the Text part.
  88. * Comment line::                What is a Comment line?
  89. * Include statements::          What are Include statements.
  90. * Special macro texts::         What is a Special macro text.
  91. * Date variables::              How Date variables can be used.
  92. Special macro texts
  93. * %s macro text::  How to use the Start of event macro text.
  94. * %e macro text::  How to use the End of event macro text.
  95. * %b macro text::  How to use the Birthday macro text.
  96. * %y macro text::  How to use the Year number macro text.
  97. * %m macro text::  How to use the Month number macro text.
  98. * %w macro text::  How to use the Week number macro text.
  99. * %d macro text::  How to use the Day number macro text.
  100. * %n macro text::  How to use the Textual date macro text.
  101. * %t macro text::  How to use the Actual time macro text.
  102. Coding scheme
  103. * Coding scheme table 1::
  104. * Coding scheme table 2::
  105. File: gcal-us.info,  Node: Gcal Introduction,  Next: Invoking Gcal,  Prev: Top,  Up: Top
  106. Gcal Introduction
  107. *****************
  108.   Apart from the usual and well known calendar functions like the
  109. output of a month or a year calendar sheet, or the output of an eternal
  110. holiday list, Gcal offers the facility to display fixed dates at the
  111. day of their occurence and to remind or inform the user about them.  So
  112. it's imaginable after boot-strapping the computer or starting the work
  113. session, that the user is informed on screen or by means of electronic
  114. mail, about all holidays or appointments, which are observed or
  115. scheduled for that day.
  116.   The period, for which Gcal respects occuring fixed dates, may be
  117. freely selected by the user.  So it's possible that Gcal displays all
  118. fixed dates, which occur on tomorrow's date, the whole week, the whole
  119. month or in the whole year.  Fixed dates which occur on a selected date
  120. of the year and those that occur relative to another given date, are
  121. displayed either related to this single date only or in listed manner
  122. starting at this date and ending (inclusive or exclusive) at the actual
  123. date.
  124.   There are two ways to display a preview of fixed dates (future years)
  125. or retrospective view of fixed dates (past years).  On the one hand,
  126. Gcal can be started using an option, which sets the system date of the
  127. computer to the given date during the time of the program execution
  128. with the result, the program assumes the system date is set to this
  129. given date and the user can define any needed period, which should be
  130. respected, by an option.  On the other hand, Gcal can be started with a
  131. command, which forces the program to use a different year instead of
  132. the actual year, so Gcal will display all occuring fixed dates for this
  133. particular year.  But this limits the user in that it disables defining
  134. any needed period by an option, because the period is always set to the
  135. whole year by default.
  136.   Gcal isn't only able to display fixed dates, which are stored for a
  137. concrete date, e.g. `Fixed date at 1'st December 1995', rather than
  138. fixed dates occuring periodically again and again.  So it's possible to
  139. define repeated events like `This fixed date occurs all days in May
  140. 1995' or `Every 15'th November in any years'.  These fixed date
  141. definitions are stored in resource files and whenever Gcal is started,
  142. an option to evaluate the necessary resource files can be given.
  143.   Once the user has set his/her preferred command line arguments for
  144. querying the fixed dates data base, it's possible to store them in a
  145. response file or shell script file.  A response file contains all
  146. arguments delivered to Gcal, but unlike a shell script file, such a
  147. response file isn't executable; it's only a pool of command line
  148. options that can be preloaded if needed.  A shell script file can be
  149. started and calls Gcal directly with all arguments, which are stored in
  150. it and all arguments, which are given further in the command line.
  151.   A description of all usable command line arguments and their
  152. descriptions is listed in the next chapter, which helps one use Gcal in
  153. the most efficient and productive way possible.
  154. File: gcal-us.info,  Node: Invoking Gcal,  Next: Eternal holidays,  Prev: Gcal Introduction,  Up: Top
  155. Invoking Gcal
  156. *************
  157.   Gcal is a command line oriented program.  It is usually called from
  158. "shell" (this is an operating system program, which interprets and runs
  159. given command lines) and processes given arguments, which are options
  160. and commands.  Options must be given before commands, i.e. you must
  161. call Gcal in this way:
  162.      gcal [ [Option...] [%Date] [@File...] ]  [Command]
  163.   If Gcal is started without any options or commands, a calendar of the
  164. current month is displayed.  If the calendar of a definite year is
  165. wanted, the year must be fully specified, e.g. `gcal 94' displays a
  166. year calendar of the year 94, not of the year 1994.
  167.   If two arguments are given in the command part, the *first* argument
  168. denotes the month and the *second* argument denotes the year.  In case
  169. any illegal commands are given running Gcal, the program will use
  170. internal defaults.
  171. * Menu:
  172. * Command line arguments::         Command line arguments.
  173. * The GCAL environment variable::  How to use the `GCAL' Environment variable.
  174. File: gcal-us.info,  Node: Command line arguments,  Next: The GCAL environment variable,  Prev: Invoking Gcal,  Up: Invoking Gcal
  175. Command line arguments
  176. ======================
  177.   This section describes all command line arguments processed by Gcal.
  178. Four different types of command line arguments exists.  One important
  179. type of argument are the "options" which control how Gcal behaves.
  180. Other types of arguments are the `%DATE' and the `@FILE' options.  The
  181. `%DATE' option sets the period Gcal shall work on to any starting date;
  182. the `@FILE' option preloads options and commands from a response file.
  183. The most important arguments are the "commands" which control the
  184. periods Gcal respects.
  185.   An option is defined by a leading "switch" character; either the `-'
  186. (dash) or the `/' (slash) character for traditional short-style options,
  187. or `--' for mnemonic long-style options; a command may not have a
  188. leading switch character!  Options (inclusive `%DATE' and `@FILE')
  189. *must* be given before commands!
  190.   Depending on operating system and used shell, some of the arguments
  191. and texts given in command line must be quoted by `"' or `'' characters
  192. respectively protected by a `\' character to avoid expansion by the
  193. shell.
  194. These characters could be:
  195.      ( ) < > [ ] { } \ | $ @ ! & ~ " ' ` ;
  196. * Menu:
  197. * Options::               How to use Options.
  198. * Response file::         How to use a `@FILE' Response file.
  199. * Actual date modifier::  How to use a `%DATE' Actual date modifier.
  200. * Commands::              How to use Commands.
  201. File: gcal-us.info,  Node: Options,  Next: Response file,  Prev: Command line arguments,  Up: Command line arguments
  202. Options
  203. -------
  204.   The options processed by Gcal can be grouped into four major option
  205. classes.  The options of the "common option class" are the standard
  206. options all GNU software should implement.  The "global option class"
  207. contains options which modify the program output.  The options of the
  208. "calendar option class" control the calendar layout, and the options of
  209. the "date warning option class" control the date warning layout and
  210. intensity.
  211.   Gcal supports both short-style options and GNU long-style options.
  212. Traditional short-style options are indicated by a single switch
  213. character and trailed by the option character itself and perhaps a
  214. modifier or an argument.  GNU long-style options are indicated with
  215. `--' and trailed by the mnemonic option name itself and perhaps an
  216. argument.  Long-style options and their arguments may be abbreviated if
  217. done unambiguously.  When a long-style option takes an argument,
  218. connect the option name and the argument with `='.  Gcal processes the
  219. GNU long-style options in a special, non-standard way.
  220. There are four different types of long-style options:
  221.   1. `--foo'
  222.      Enables option `--foo'.
  223.   2. `--foo=BAR'
  224.      Enables option `--foo' with required argument BAR.
  225.   3. `--foo[=BAR[|...|BAR]]'
  226.      Option `--foo' may have one BAR argument.  If no argument list is
  227.      given, any argument can be given to this option.  If an argument
  228.      list is given, exactly one BAR argument may be selected from given
  229.      list.  If there is no argument choosen in this case, the first BAR
  230.      argument of the argument list is pre-selected by default.
  231.   4. `--foo=BAR|...|BAR'
  232.      Option `--foo' requires exactly one BAR argument, which must be
  233.      selected from given argument list.
  234. Traditional short-style options differ as follows:
  235.   1. `-x'
  236.      Enables option `-x'.
  237.   2. `-x BAR'
  238.      Enables option `-x' with required argument BAR.  The BAR argument
  239.      may be separated by a leading *whitespace* character from the
  240.      short-style option character `x'.  This means following notations
  241.      are valid for giving an argument, namely `-x BAR' or `-xBAR'.
  242.   3. `-x[BAR|...|BAR]'
  243.      Option `-x' may have one or more BAR "modifier".  In this sense,
  244.      modifiers are one or more characters which define a special mode
  245.      of operation enabled by the `-x' option.  A modifier may not be
  246.      separated by a leading *whitespace* character from the short-style
  247.      option character.
  248. * Menu:
  249. * Common options::        How to use Common options.
  250. * Global options::        How to use Global options.
  251. * Calendar options::      How to use Calendar options.
  252. * Date warning options::  How to use Date warning options.
  253. File: gcal-us.info,  Node: Common options,  Next: Global options,  Prev: Options,  Up: Options
  254. Common options
  255. ..............
  256. `--help'
  257.      Print a short usage message listing most of all available options,
  258.      then exit successfully.
  259. `-??'
  260. `-hh'
  261. `--usage[=ARG]'
  262. `--long-help[=ARG]'
  263.      Print an extended usage message listing all available options,
  264.      then exit successfully.  If ARG is given and is a valid long
  265.      option name, an extended help text related to the given long
  266.      option name is displayed only, e.g.:
  267.           --long-help=long-help
  268.      displays the extended help text for the long option `--long-help'.
  269. `--license'
  270. `--copyleft'
  271. `--copyright'
  272.      Print the software license message, then exit successfully.
  273. `--version'
  274.      Print the version number and compilation options, then exit
  275.      successfully.
  276. File: gcal-us.info,  Node: Global options,  Next: Calendar options,  Prev: Common options,  Up: Options
  277. Global options
  278. ..............
  279. `-R NAME'
  280. `--response-file=ARG'
  281.      Write contents of environment variable `GCAL' (*note GCAL:
  282.      Environment variables.), and then arguments of command line (in
  283.      the given order) to file NAME, i.e. create response file `name'.
  284.      *Note Response file::, for more details.
  285. `-S NAME'
  286. `--shell-script=ARG'
  287.      Write contents of environment variable `GCAL' (*note GCAL:
  288.      Environment variables.), and then arguments of command line (in
  289.      the given order) to shell script file NAME, i.e. create file
  290.      `name'.  An automatically created shell script file is executable
  291.      and calls Gcal directly with the arguments, which are stored in
  292.      it.  You may start the shell script with further command line
  293.      arguments, which are directed to Gcal too.
  294. `--debug[=internal|handled|unhandled|all|abort]'
  295.      Display some debug informations.
  296.     `--debug=internal'
  297.           Display warnings if program internal maximums are reached.
  298.     `--debug=handled'
  299.           Like `--debug=internal' and display file names which are
  300.           handled, too.
  301.     `--debug=unhandled'
  302.           Like `--debug=internal' and display file names which are
  303.           unhandled, too.
  304.     `--debug=all'
  305.           Like `--debug=handled' and `--debug=unhandled' together.
  306.     `--debug=abort'
  307.           Like `--debug=all' and abort program with error if file name
  308.           can't be handled, see *Note 118: Error codes.
  309. `--pager'
  310.      Enables either an *external* pager or a simple *internal* pager.
  311.      If an environment variable `PAGER' is set, its value will be used
  312.      for detecting the external pager program.  *Note PAGER:
  313.      Environment variables, for more information.
  314.      If no `PAGER' environment variable is set or if its value is
  315.      invalid, Gcal tries to use the `less' pager; if this program can't
  316.      be found during scanning the `PATH' environment variable, Gcal
  317.      tries to use the `more' pager in the same way (1).  *Note PATH:
  318.      Environment variables.
  319.      If all these actions fail, Gcal will use its simple, built-in
  320.      pager.  If the internal pager is used, Gcal detects the number of
  321.      lines shown before it prompts and waits for user input using these
  322.      methods:
  323.        1. Gcal respects the values set in the environment variables
  324.           `LINES' and `COLUMNS'.  *Note LINES: Environment variables,
  325.           and see *Note COLUMNS: Environment variables, for more
  326.           details.
  327.        2. If above action fails, Gcal respects the values set in the
  328.           environment variables `LI' and `CO'.  *Note LI: Environment
  329.           variables, and see *Note CO: Environment variables, for more
  330.           details.
  331.        3. If above actions fails, Gcal uses a system dependent
  332.           *low-level* function and respects the reported values.
  333.        4. If above action fails, Gcal respects the values set in the
  334.           `termcap' (2) file, which refers to the terminal used (*note
  335.           TERM: Environment variables.).  This step is only done on
  336.           systems which support the use of Termcap.
  337.        5. If all above actions fail, Gcal uses default values (either
  338.           23 or 24 lines, 80 columns).
  339. `-H yes'
  340. `--force-highlighting'
  341. `--highlighting=yes'
  342.      If output of the program is redirected or piped, the highlighting
  343.      sequences are *not* converted automatically into the according
  344.      marking characters, they remain unchanged.
  345. `-H no'
  346. `--disable-highlighting'
  347. `--highlighting=no'
  348.      Disable highlighting sequence / marking character pairs of current
  349.      day, holiday resp., text explicitly.
  350. `-H TEXT'
  351. `--highlighting=ARG'
  352.      Set highlighting sequence / marking character pairs explicitly.
  353.      In this sense, "highlighting" sequences are control character
  354.      sequences which cause a colour or intensity switch of output text.
  355.      Typical control character sequences are the ANSI escape
  356.      sequences, which have a leading escape character and trailing more
  357.      characters, which define the type of the ANSI escape sequence.  In
  358.      this sense, "marking" characters are single, printable characters,
  359.      which lead and succeed the output text.
  360.      The argument TEXT must be a (`:') colon-separated text, which is
  361.      structured in this way: SEQ1_START:SEQ1_END:SEQ2_START:SEQ2_END.
  362.      The *first* sequence is used for highlighting/marking the actual
  363.      day, the *second* for holiday.  The sequences must be given in
  364.      form of a sequence pair; SEQ?_START enables the
  365.      highlighting/marking, SEQ?_END disables it.  Only two sequence
  366.      pairs will be processed, others are ignored.  Either highlighting
  367.      sequence pairs or marking character pairs may be defined, i.e.
  368.      using them both in a mixed couple is not allowed!
  369.      Some examples:
  370.           `-H \x20:\x20:\x1:#' respectively
  371.           `--highlighting=\x20:\x20:\x1:#'
  372.           marks the actual day like `\x20ACTUAL DATE\x20' (this means
  373.           with leading and trailing blanks) and the holiday date like
  374.           `\x1HOLIDAY DATE#' using given marking characters.
  375.           `-H \x1b[34;42m:\x1b[0;40m' or
  376.           `-H \033[34;42m:\033[0;40m' or
  377.           `-H \E[34;42m:\E[0;40m'
  378.           defines a starting ANSI escape highlighting sequence
  379.           `\x1b[34;42m' used for actual day and ending ANSI escape
  380.           highlighting sequence `\x1b[0;40m' with no given highlighting
  381.           sequence for holiday, so default highlighting sequences for
  382.           holidays are used (unnotated entries are always skipped).
  383.           Please note the last abstract of this text part, which
  384.           informs you more detailled to this coherence. *Note GCALANSI:
  385.           Environment variables.
  386.      Control code definitions may contain any printable characters.
  387.      Non-printable characters may be encoded in octal or hexadecimal
  388.      notation.  The abbreviation `\E' directly encodes the escape
  389.      character (octal `\033' respectively hexadecimal `\x1B').
  390.      A character can be encoded octal by typing `\NNN'
  391.      (backslash-octal digit(s)), where N must be a valid octal digit
  392.      (0...7).  Normally, three octal digits must be given.  If the octal
  393.      character code consists of one or two octal digits, leading zeroes
  394.      must be added; except the case where the encoded octal character
  395.      is given last in single sequence.
  396.      A character can be encoded hexadecimal by typing `\xNN'
  397.      (backslash-x-hexadecimal digit(s)), where N must be a valid
  398.      hexadecimal digit (0...9A...Fa...f).  Normally, two hexadecimal
  399.      digits must be given.  If the hexadecimal character code consists
  400.      of one hexadecimal digit, a leading zero must be added; except the
  401.      case where the encoded hexadecimal character is given last in
  402.      single sequence.
  403.      If the sequence separator character, the `:' (colon) character
  404.      itself is used for marking character, it must be encoded either
  405.      octal by `\072' or hexadecimal by `\x3A'.
  406.      If the C Preprocessor symbol USE_PAGER was defined and output of
  407.      program is redirected or piped, the highlighting sequences are
  408.      converted automatically into the according marking characters; if
  409.      USE_PAGER was not defined, they remain untouched.
  410.      Incomplete or no given highlighting sequences will be replaced by
  411.      internal default ANSI escape highlighting sequences if a `GCALANSI'
  412.      environment variable is defined; otherwise completely replaced by
  413.      their according marking characters.  *Note GCALANSI: Environment
  414.      variables.
  415. `-m ADR'
  416. `--mail=ARG'
  417.      Send Gcal's output via `mail' (3) program to Email address ADR,
  418.      e.g.:
  419.           --mail=root
  420.           -m esken@uni-muenster.de
  421.   ---------- Footnotes ----------
  422.   (1)  See the standard *manual* pages for `less' and `more'.
  423.   (2)  See the standard *manual* pages for Termcap.
  424.   (3)  See the standard *manual* pages for `mail'.
  425. File: gcal-us.info,  Node: Calendar options,  Next: Date warning options,  Prev: Global options,  Up: Options
  426. Calendar options
  427. ................
  428. `-n|N[-]'
  429. `--descending-holiday-list[=long|short]'
  430. `--holiday-list[=long|short]'
  431.      Display an eternal holiday list.  *Note Eternal holidays::, for
  432.      additional information.
  433.     `-n'
  434.     `--holiday-list=long'
  435.           Display all holidays in eternal holiday list sorted in
  436.           ascending order.
  437.     `-n-'
  438.     `--descending-holiday-list=long'
  439.           Display all holidays in eternal holiday list sorted in
  440.           descending order.
  441.     `-N'
  442.     `--holiday-list=short'
  443.           Display legal days only in eternal holiday list sorted in
  444.           ascending order.
  445.     `-N-'
  446.     `--descending-holiday-list=short'
  447.           Display legal days only in eternal holiday list sorted in
  448.           descending order.
  449. `--exclude-holiday-list-title'
  450.      Suppresses the title text line of the eternal holiday list.
  451. `-i[-]'
  452. `--type=special|standard'
  453.      To get the "standard" calendar format (similar BSD-`cal'), start
  454.      Gcal omitting the `-i[-]' option because it is set by default, or
  455.      by giving the `-i-' respectively the `--type=standard' option to
  456.      force the output of a calendar sheet:
  457.           % gcal -i-
  458.           
  459.               September 1994
  460.            Su Mo Tu We Th Fr Sa
  461.                         1  2  3
  462.             4  5  6  7  8  9 10
  463.            11 12 13 14 15 16 17
  464.            18 19 20 21 22 23 24
  465.            25 26 27 28 29 30
  466.      To get the "special" calendar format and to force the output of a
  467.      calendar sheet, start Gcal with the `-i' respectively the
  468.      `--type=special' option:
  469.           % gcal -i
  470.           
  471.            September 1994
  472.           
  473.            Sunday          4 11 18 25
  474.            Monday          5 12 19 26
  475.            Tuesday         6 13 20 27
  476.            Wednesday       7 14 21 28
  477.            Thursday     1  8 15 22 29
  478.            Friday       2  9 16 23 30
  479.            Saturday     3 10 17 24
  480. `--suppress-calendar'
  481.      Suppress output of calendar sheet explicitly.
  482. `-b NUMBER'
  483. `--blocks=ARG'
  484.      Set number of calendar sheet blocks (valid arguments:
  485.      `1|2|3|4|6|12').  The default value for the *standard* calendar
  486.      format is `-b4 ' respectively `--blocks=4', and for the *special*
  487.      calendar format `-b 3' respectively `--blocks=3'.  If this option
  488.      is found, the program sees that a year calendar output is desired!
  489.     `-b 1'
  490.     `--blocks=1'
  491.           Displays one block with twelve months at a time.
  492.     `-b 2'
  493.     `--blocks=2'
  494.           Displays two blocks with six months at a time.
  495.     `-b 3'
  496.     `--blocks=3'
  497.           Displays three blocks with four months at a time.
  498.     `-b 4'
  499.     `--blocks=4'
  500.           Displays four blocks with three months at a time.
  501.     `-b 6'
  502.     `--blocks=6'
  503.           Displays six blocks with two months at a time.
  504.     `-b 12'
  505.     `--blocks=12'
  506.           Displays twelve blocks with one month at a time.
  507. `-j[b]'
  508. `--calendar-dates=julian|both'
  509.      Use alternative date format in calendar sheet.
  510.     `-j'
  511.     `--calendar-dates=julian'
  512.           Display calendar sheet using Julian date format.
  513.     `-jb'
  514.     `--calendar-dates=both'
  515.           Display calendar sheet using standard- and Julian date format.
  516. `-jn[b]'
  517. `--holiday-dates=julian|both'
  518.      Use alternative date format in eternal holiday list.  *Note
  519.      `--holiday-list[=long|short]': Calendar options.
  520.     `-jn'
  521.     `--holiday-dates=julian'
  522.           Display eternal holiday list using Julian date format.
  523.     `-jnb'
  524.     `--holiday-dates=both'
  525.           Display eternal holiday list using standard- and Julian date
  526.           format.
  527. `-jc[b]'
  528. `--fixed-dates=julian|both'
  529.      Use alternative date format in fixed date warning list.  *Note
  530.      `--list-of-fixed-dates[=short|long]': Date warning options.
  531.     `-jc'
  532.     `--fixed-dates=julian'
  533.           Display fixed date warning list using Julian date format.
  534.     `-jcb'
  535.     `--fixed-dates=both'
  536.           Display fixed date warning list using standard- and Julian
  537.           date format.
  538. `-s ARG'
  539. `--starting-day=ARG'
  540.      Set the starting day of week (valid arguments:
  541.      `0, 1...7 | WEEKDAY NAME').
  542.      Example:
  543.           --starting-day=7 or
  544.           -s 7 or
  545.           -s Su or
  546.           -s sund or
  547.           -s SUNDAY
  548.      thus all specifies the Sunday (1==Mon, 2==Tue ... 7==Sun).
  549.      If the `-s 0' option respectively the `--starting-day=0' option is
  550.      given, the starting day of week is set to the actual weekday.
  551.